// 数据库服务API - 与Wails后端通信
import * as DatabaseServiceBindings from '../../bindings/changeme/internal/services/databaseservice.js'

class DatabaseServiceAPI {
  constructor() {
    // 检查是否在Wails环境中
    this.isWailsEnv = typeof window !== 'undefined' && window.wails
  }

  // 配置管理方法

  /**
   * 保存数据库配置
   * @param {Object} config - 数据库配置对象
   * @returns {Promise<Object>} 保存的配置
   */
  async saveConfig(config) {
    return await DatabaseServiceBindings.SaveConfig(config)
  }

  /**
   * 获取数据库配置
   * @param {string} id - 配置ID
   * @returns {Promise<Object>} 配置对象
   */
  async getConfig(id) {
    return await DatabaseServiceBindings.GetConfig(id)
  }

  /**
   * 获取所有数据库配置
   * @returns {Promise<Array>} 配置列表
   */
  async getAllConfigs() {
    return await DatabaseServiceBindings.GetAllConfigs()
  }

  /**
   * 删除数据库配置
   * @param {string} id - 配置ID
   * @returns {Promise<void>}
   */
  async deleteConfig(id) {
    return await DatabaseServiceBindings.DeleteConfig(id)
  }

  /**
   * 更新数据库配置
   * @param {Object} config - 配置对象
   * @returns {Promise<Object>} 更新后的配置
   */
  async updateConfig(config) {
    return await DatabaseServiceBindings.UpdateConfig(config)
  }

  /**
   * 设置默认数据库配置
   * @param {string} id - 配置ID
   * @returns {Promise<void>}
   */
  async setDefaultConfig(id) {
    return await DatabaseServiceBindings.SetDefaultConfig(id)
  }

  /**
   * 获取默认数据库配置
   * @returns {Promise<Object>} 默认配置
   */
  async getDefaultConfig() {
    return await DatabaseServiceBindings.GetDefaultConfig()
  }

  // 连接管理方法

  /**
   * 测试数据库连接
   * @param {Object} config - 数据库配置
   * @returns {Promise<void>}
   */
  async testConnection(config) {
    return await DatabaseServiceBindings.TestConnection(config)
  }

  /**
   * 获取连接状态
   * @param {string} configId - 配置ID
   * @returns {Promise<Object>} 连接状态
   */
  async getConnectionStatus(configId) {
    return await DatabaseServiceBindings.GetConnectionStatus(configId)
  }

  /**
   * 关闭数据库连接
   * @param {string} configId - 配置ID
   * @returns {Promise<void>}
   */
  async closeConnection(configId) {
    return await DatabaseServiceBindings.CloseConnection(configId)
  }

  /**
   * 关闭所有数据库连接
   * @returns {Promise<void>}
   */
  async closeAllConnections() {
    return await DatabaseServiceBindings.CloseAllConnections()
  }

  // 数据库操作方法

  /**
   * 列出数据库
   * @param {string} configId - 配置ID
   * @returns {Promise<Array>} 数据库列表
   */
  async listDatabases(configId) {
    return await DatabaseServiceBindings.ListDatabases(configId)
  }

  /**
   * 列出表
   * @param {string} configId - 配置ID
   * @param {string} database - 数据库名
   * @returns {Promise<Array>} 表列表
   */
  async listTables(configId, database) {
    return await DatabaseServiceBindings.ListTables(configId, database)
  }

  /**
   * 获取表列信息
   * @param {string} configId - 配置ID
   * @param {string} database - 数据库名
   * @param {string} table - 表名
   * @returns {Promise<Array>} 列信息列表
   */
  async getTableColumns(configId, database, table) {
    return await DatabaseServiceBindings.GetTableColumns(configId, database, table)
  }

  /**
   * 获取表索引信息
   * @param {string} configId - 配置ID
   * @param {string} database - 数据库名
   * @param {string} table - 表名
   * @returns {Promise<Array>} 索引信息列表
   */
  async getTableIndexes(configId, database, table) {
    return await DatabaseServiceBindings.GetTableIndexes(configId, database, table)
  }

  /**
   * 执行查询
   * @param {string} configId - 配置ID
   * @param {string} query - SQL查询语句
   * @param {...any} args - 查询参数
   * @returns {Promise<Object>} 查询结果
   */
  async executeQuery(configId, query, ...args) {
    return await DatabaseServiceBindings.ExecuteQuery(configId, query, ...args)
  }

  /**
   * 执行非查询语句
   * @param {string} configId - 配置ID
   * @param {string} query - SQL语句
   * @param {...any} args - 查询参数
   * @returns {Promise<number>} 影响的行数
   */
  async executeNonQuery(configId, query, ...args) {
    return await DatabaseServiceBindings.ExecuteNonQuery(configId, query, ...args)
  }

  /**
   * 批量执行SQL语句
   * @param {string} configId - 配置ID
   * @param {Array<string>} sqlStatements - SQL语句数组
   * @returns {Promise<Object>} 批量执行结果
   */
  async executeBatchSQL(configId, sqlStatements) {
    return await DatabaseServiceBindings.ExecuteBatchSQL(configId, sqlStatements)
  }

  /**
   * 修改表结构
   * @param {string} configId - 配置ID
   * @param {string} database - 数据库名
   * @param {string} table - 表名
   * @param {Object} alterSchema - 表修改结构
   * @returns {Promise<void>}
   */
  async AlterTable(configId, database, table, alterSchema) {
    return await DatabaseServiceBindings.AlterTable(configId, database, table, alterSchema)
  }

  /**
   * 删除表
   * @param {string} configId - 配置ID
   * @param {string} database - 数据库名
   * @param {string} table - 表名
   * @param {boolean} cascade - 是否级联删除
   * @returns {Promise<void>}
   */
  async dropTable(configId, database, table, cascade = false) {
    return await DatabaseServiceBindings.DropTable(configId, database, table, cascade)
  }

  /**
   * 清空表
   * @param {string} configId - 配置ID
   * @param {string} database - 数据库名
   * @param {string} table - 表名
   * @returns {Promise<void>}
   */
  async truncateTable(configId, database, table) {
    return await DatabaseServiceBindings.TruncateTable(configId, database, table)
  }

  /**
   * 重命名表
   * @param {string} configId - 配置ID
   * @param {string} database - 数据库名
   * @param {string} oldTable - 旧表名
   * @param {string} newTable - 新表名
   * @returns {Promise<void>}
   */
  async renameTable(configId, database, oldTable, newTable) {
    return await DatabaseServiceBindings.RenameTable(configId, database, oldTable, newTable)
  }

  /**
   * 打开导入窗口
   * @param {Object} config - 导入配置
   * @returns {Promise<Object>} 窗口信息
   */
  async openImportWindow(config) {
    // 调用后端获取导入配置
    const result = await DatabaseServiceBindings.OpenImportWindow(config)
    
    if (result.error) {
      throw new Error(result.error)
    }
    
    // 返回配置信息，导航逻辑由调用方处理
    return result
  }

  // 工具方法

  /**
   * 获取支持的数据库类型
   * @returns {Promise<Array>} 支持的数据库类型列表
   */
  async getSupportedDatabaseTypes() {
    return await DatabaseServiceBindings.GetSupportedDatabaseTypes()
  }

  /**
   * 获取数据库类型信息
   * @returns {Promise<Object>} 数据库类型信息
   */
  async getDatabaseTypeInfo() {
    return await DatabaseServiceBindings.GetDatabaseTypeInfo()
  }

  /**
   * 验证数据库配置
   * @param {Object} config - 数据库配置
   * @returns {Promise<void>}
   */
  async validateConfig(config) {
    return await DatabaseServiceBindings.ValidateConfig(config)
  }

  /**
   * 获取数据库类型的默认配置
   * @param {string} dbType - 数据库类型
   * @returns {Promise<Object>} 默认配置
   */
  async getDefaultConfigForType(dbType) {
    return await DatabaseServiceBindings.GetDefaultConfigForType(dbType)
  }

  // 文件导入相关方法
  async parseImportFile(fileData, fileType, config) {
    try {
      const response = await DatabaseServiceBindings.ParseImportFile(fileData, fileType, config)
      return response
    } catch (error) {
      console.error('Parse import file error:', error)
      throw error
    }
  }

  async executeImport(params) {
    try {
      const response = await DatabaseServiceBindings.ExecuteImport(params)
      return response
    } catch (error) {
      console.error('Execute import error:', error)
      throw error
    }
  }
}

// 创建单例实例
export const DatabaseService = new DatabaseServiceAPI()

// 数据库类型常量
export const DatabaseTypes = {
  MYSQL: 'mysql',
  POSTGRESQL: 'postgresql',
  SQLITE: 'sqlite',
  SQLSERVER: 'sqlserver',
  DAMENG: 'dameng'
}

// 连接状态常量
export const ConnectionStatus = {
  DISCONNECTED: 'disconnected',
  CONNECTING: 'connecting',
  CONNECTED: 'connected',
  ERROR: 'error'
}

// 表类型常量
export const TableTypes = {
  TABLE: 'TABLE',
  VIEW: 'VIEW',
  SYSTEM_TABLE: 'SYSTEM TABLE',
  TEMPORARY: 'TEMPORARY'
}

// 列数据类型映射
export const DataTypeMapping = {
  // MySQL类型
  'varchar': 'VARCHAR',
  'char': 'CHAR',
  'text': 'TEXT',
  'int': 'INT',
  'bigint': 'BIGINT',
  'decimal': 'DECIMAL',
  'float': 'FLOAT',
  'double': 'DOUBLE',
  'datetime': 'DATETIME',
  'timestamp': 'TIMESTAMP',
  'date': 'DATE',
  'time': 'TIME',
  'boolean': 'BOOLEAN',
  'json': 'JSON',
  
  // PostgreSQL类型
  'integer': 'INTEGER',
  'real': 'REAL',
  'jsonb': 'JSONB',
  'uuid': 'UUID',
  
  // SQLite类型
  'blob': 'BLOB',
  
  // SQL Server类型
  'nvarchar': 'NVARCHAR',
  'bit': 'BIT'
}

// 默认端口映射
export const DefaultPorts = {
  [DatabaseTypes.MYSQL]: 3306,
  [DatabaseTypes.POSTGRESQL]: 5432,
  [DatabaseTypes.SQLSERVER]: 1433,
  [DatabaseTypes.SQLITE]: 0,
  [DatabaseTypes.DAMENG]: 5236
}

// 工具函数

/**
 * 格式化数据库连接字符串显示
 * @param {Object} config - 数据库配置
 * @returns {string} 格式化的连接字符串
 */
export function formatConnectionString(config) {
  if (!config) return ''
  
  switch (config.type) {
    case DatabaseTypes.MYSQL:
    case DatabaseTypes.POSTGRESQL:
    case DatabaseTypes.SQLSERVER:
      return `${config.type}://${config.username}@${config.host}:${config.port}/`
    case DatabaseTypes.SQLITE:
      return `sqlite://${config.filePath}`
    default:
      return config.name || 'Unknown'
  }
}

/**
 * 获取数据库类型图标
 * @param {string} type - 数据库类型
 * @returns {string} 图标名称
 */
export function getDatabaseTypeIcon(type) {
  const iconMap = {
    [DatabaseTypes.MYSQL]: 'mysql',
    [DatabaseTypes.POSTGRESQL]: 'postgresql',
    [DatabaseTypes.SQLITE]: 'sqlite',
    [DatabaseTypes.SQLSERVER]: 'sqlserver',
    [DatabaseTypes.DAMENG]: 'dameng'
  }
  return iconMap[type] || 'database'
}

/**
 * 验证连接配置
 * @param {Object} config - 数据库配置
 * @returns {Array} 验证错误列表
 */
export function validateConnectionConfig(config) {
  const errors = []
  
  if (!config.name?.trim()) {
    errors.push('连接名称不能为空')
  }
  
  if (!config.type) {
    errors.push('请选择数据库类型')
  }
  
  if (config.type === DatabaseTypes.SQLITE) {
    if (!config.filePath?.trim()) {
      errors.push('SQLite文件路径不能为空')
    }
  } else {
    if (!config.host?.trim()) {
      errors.push('主机地址不能为空')
    }
    
    if (!config.port || config.port <= 0 || config.port > 65535) {
      errors.push('端口号必须在1-65535之间')
    }
    
    if (!config.username?.trim()) {
      errors.push('用户名不能为空')
    }
    
    // 注意：不再验证database字段，因为我们连接到服务器而不是特定数据库
  }
  
  return errors
}

export default DatabaseService 

